1️⃣ Objectifs

Créer un fusil à plasma capable de générer, confiner et propulser un plasma ionisé grâce à des composants simples et disponibles.

Pourquoi ? Ce projet éducatif vous permet d’apprendre comment fonctionne le plasma, les champs magnétiques et les circuits électroniques complexes, tout en développant vos compétences techniques.

Pour qui ? Ce tutoriel est conçu pour les curieux de science et technologie, même sans expérience préalable. Chaque étape est détaillée pour que même un enfant, avec de l’aide, puisse suivre.

2️⃣ Spécifications Techniques

• Taille : Longueur : 80 cm, largeur : 10 cm.
• Poids : 4 à 5 kg.
• Portée : 1-3 mètres (environ la taille d'une pièce).
• Alimentation : Batterie LiPo 22.2V, 10Ah avec convertisseur 22.2V→48V si requis.
• Plasma : 50 kV, arc stable visible et lumineux.
• Confinement Magnétique : Jusqu’à 1 Tesla (suffisant pour guider le plasma).
• Propulsion : 2880 J par décharge, projetant le plasma hors du tube.

3️⃣ Composants Avancés

Schéma Électrique Détaillé

[Alimentation 22.2V]──[Convertisseur DC-DC 450V]──[Multiplicateur HV]──[Électrodes]
                         │                          │
[Arduino Mega]──[Driver MOSFET]──[Bobines Helmholtz]           [Capteur Hall]
                         │
[Supercondensateur 1000F]─[Relais HV]──[Bobine Accélératrice]
            

4️⃣ Fondements Théoriques

Équations Clés

Optimisation de Portée

Pour atteindre 10 m :

Paramètres requis :
- Énergie : ≥15 kJ (augmenter supercondensateur à 3000F)
- Tension : 100 kV (ajouter étage multiplicateur Cockcroft-Walton)
- Bobines : 20 tours/cm (augmenter densité magnétique)
- Vide partiel : 0.1 atm (réduire la résistance du milieu)
            

5️⃣ Étapes de Construction

Ajout de la Gâchette

Pourquoi ajouter une gâchette ?

Une gâchette permet de contrôler manuellement le tir, garantissant la sécurité et la précision.

Instructions :

1. Connectez une borne du bouton-poussoir à une broche numérique de l'Arduino (par exemple, broche 7).
2. Connectez l'autre borne du bouton à la masse (GND).
3. Ajoutez une résistance de pull-down (10 kΩ) entre la broche numérique et la masse pour stabiliser le signal.

Schéma ASCII :

   +5V (Arduino)
      |
     [ ] Bouton-poussoir
      |
   Pin 7 (Arduino)
      |
   [10kΩ] Résistance pull-down
      |
   GND (Arduino)
            

Code Arduino :

const int relayPin = 8; // Broche pour contrôler le relais
const int sensorPin = 2; // Capteur (IR ou Hall)
const int triggerPin = 7; // Gâchette (bouton-poussoir)
void setup() {
  pinMode(relayPin, OUTPUT); 
  pinMode(sensorPin, INPUT);
  pinMode(triggerPin, INPUT_PULLUP); 
}
void loop() {
  if (digitalRead(sensorPin) == HIGH && digitalRead(triggerPin) == LOW) {
    digitalWrite(relayPin, HIGH);
    delay(50);
    digitalWrite(relayPin, LOW);
  }
}
            

Étape 1 : Génération de Plasma

Pourquoi cela fonctionne ?

Un plasma se forme lorsqu’un courant électrique ionise l'air ambiant en brisant ses molécules. Cela crée un gaz conducteur visible sous forme d’un arc lumineux.

Instructions :

1. Préparer le Transformateur Flyback :
   • Connectez les bornes primaires du Flyback à un convertisseur DC-DC (12-24V).
   • Reliez les bornes secondaires à un condensateur haute tension (10 kV, 100 nF) pour stabiliser la tension.
2. Installer les Électrodes :
   • Placez deux électrodes en tungstène dans un tube en verre (espacement : 5 mm).
   • Connectez chaque électrode aux bornes secondaires du Flyback.
3. Tester :
   • Branchez la batterie et observez un arc lumineux entre les électrodes. Si rien ne se passe, vérifiez vos connexions.

Schéma ASCII :

   +24V (Batterie)
      |
   [Flyback]
      |
   [Condensateur 10kV]
      |
   [Électrodes Tungstène]
            

Conseil pour débutants :

Si l’arc n’apparaît pas, vérifiez que la batterie est bien chargée et que toutes les connexions sont solides.

Étape 2 : Confinement Magnétique

Pourquoi cela fonctionne ?

Les champs magnétiques générés par les bobines interagissent avec les particules chargées du plasma, le guidant à travers le tube.

Instructions :

1. Créer les Bobines :
   • Enroulez 50 tours de fil de cuivre autour du tube, en espaçant chaque bobine de 2 cm.
   • Fixez chaque bobine avec du ruban isolant pour éviter qu’elles ne bougent.
2. Connecter les MOSFET :
   • Reliez chaque bobine au Drain d’un MOSFET et connectez la Source au GND.
   • Les Gates des MOSFET sont connectées à l’Arduino pour leur activation.
3. Programmer l’Arduino :

   int coilPins[] = {3, 5, 6, 9, 10, 11, 12, 13, A0, A1}; // Broches reliées aux MOSFET des bobines
   void setup() {
     for (int i = 0; i < 10; i++) {
       pinMode(coilPins[i], OUTPUT); // Configure les broches des bobines en sortie
     }
   }
   void loop() {
     for (int i = 0; i < 10; i++) {
       digitalWrite(coilPins[i], HIGH); // Active une bobine
       delay(100); // Maintient la bobine active pendant 100 ms
       digitalWrite(coilPins[i], LOW); // Désactive la bobine
     }
   }
                       

Schéma ASCII :

   [Bobine 1] -- [MOSFET 1] -- Arduino
   [Bobine 2] -- [MOSFET 2] -- Arduino
   [Bobine 3] -- [MOSFET 3] -- Arduino
   [Bobine 4] -- [MOSFET 4] -- Arduino
   [Bobine 5] -- [MOSFET 5] -- Arduino
   [Bobine 6] -- [MOSFET 6] -- Arduino
            

Astuce pour débutants :

Si une bobine ne fonctionne pas, testez-la avec un multimètre pour vérifier qu’elle est correctement connectée.

Étape 3 : Propulsion

Pourquoi cela fonctionne ?

Le supercondensateur libère une décharge rapide dans une bobine finale, produisant un champ magnétique puissant pour propulser le plasma.

Instructions :

1. Installer la Bobine Finale :
   • Enroulez 15 tours de fil de cuivre à l’extrémité du tube.
   • Connectez la bobine au relais haute puissance.
2. Connecter le Supercondensateur :
   • Reliez-le à la bobine via le relais et ajoutez une diode haute puissance pour éviter les retours de courant.
3. Programmer l’Arduino :

   const int relayPin = 8; // Broche pour contrôler le relais
   const int sensorPin = 2; // Broche reliée au capteur (IR ou Hall)
   void setup() {
     pinMode(relayPin, OUTPUT); // Configure le relais en sortie
     pinMode(sensorPin, INPUT); // Configure le capteur en entrée
   }
   void loop() {
     if (digitalRead(sensorPin) == HIGH) { // Si le plasma est détecté
       digitalWrite(relayPin, HIGH); // Active le relais pour propulser
       delay(50); // Maintient la décharge pendant 50 ms
       digitalWrite(relayPin, LOW); // Désactive le relais
     }
   }
                       

Schéma ASCII :

   [Supercondensateur] -- [Relais] -- [Bobine Finale]
            

6️⃣ Modélisation Mathématique

Calcul de Puissance

Thermodynamique du Plasma

Température des électrons :
kTₑ ≈ eEλₑ ≈ 1.6e-19 × 1e6 × 0.1 ≈ 10 eV (∼116,000K)
Densité critique :
nₑ = ε₀mₑω²/e² ≈ 1e18 m⁻³ (pour f=1MHz)
            

7️⃣ Techniques Avancées

Contrôle en Boucle Fermée

// Code Arduino optimisé avec PID
#include 
double Setpoint, Input, Output;
PID myPID(&Input, &Output, &Setpoint, 2,5,1, DIRECT);
void setup() {
  myPID.SetMode(AUTOMATIC);
  myPID.SetSampleTime(1);
}
void loop() {
  Input = analogRead(sensorPin)/1024.0*5000; // Lecture capteur
  Setpoint = 3000; // 3kV cible
  myPID.Compute();
  analogWrite(MOSFETpin, Output/5000.0*255); // Correction PWM
}
            

Refroidissement Cryogénique

Schéma d'installation :

[Réservoir LN2]──[Échangeur Cuivre]──[Bobines]
       │                │
[Ventilateur]   [Capteur Température]
            

8️⃣ Protocoles de Sécurité

Schéma de Mise à la Terre

[Châssis]──[Piquet Terre Cuivre]──[Réseau Terre Bâtiment]
  │             │
[Fil 25mm²]  [Résistance 10Ω]
            

9️⃣ Schémas de Câblage Avancés

Architecture Principale (ASCII)

                           [Alim 22.2V]
                              │
        ┌───────────┬─────────┼─────────┬───────────┐
        │           │         │         │           │
     [PFC]   [Convertisseur] [MCU]   [Capteurs]  [Interface]
     900W      22V→450V     Arduino     IR/Hall    Utilisateur
        │           │         │             │
        └─────┬─────┘         └──────┬──────┘
              │                      │
           [Stockage Énergie]    [Contrôle]
          1000F @ 450V          PID Magnétique
              │
        ┌─────┴─────┐
        │           │
  [Bobines HV]  [Accélérateur]
  20x Ø200mm     Électrostatique
            

Détail Alimentation Haute Tension

[22.2V DC]──[IR2153]──[Transformateur Ferrite]──[Multiplicateur 10 étages]
               │           1:100                   │         │         │
            [MOSFET]                           [Diodes 20kV] [Condensateurs 2nF]
                                                       │
                                                    [Électrode]
            

🔟 Procédures de Test Rigoureuses

Test Final de Performance

1. Charger supercondensateur à 450V
2. Amorcer plasma avec impulsion 100μs
3. Activer séquence confinement (bobine 1 → 20)
4. Déclencher accélérateur au point t=20ms
5. Mesurer avec :
   - Spectromètre optique (température plasma)
   - Caméra rapide 100,000 fps
   - Calorimètre à impact (énergie transférée)
            

1️⃣1️⃣ Analyse des Modes de Défaillance (AMDEC)

Arbre de Défaillance Critique

Perte confinement plasma
  ├── Alim HV instable
  │    ├── Ondulation > 5%
  │    └── Dérive thermique
  └── Désynchronisation bobines
       ├── Erreur timing Arduino
       └── Bruit EMI
            

1️⃣2️⃣ Certifications Requises

1️⃣3️⃣ Code Complet du Système de Contrôle

/*
 * Contrôleur Principal Fusil Plasma v2.3
 * Fonctionnalités :
 * - Gestion séquentielle des bobines
 * - Régulation PID de la température
 * - Protocole de sécurité SIL 2
 * - Interface utilisateur OLED
 */
#include 
#include 
#include 
// Configuration Matérielle
#define COIL_PINS {3,5,6,9,10,11,12,13,A0,A1}
#define TEMP_SENSOR A2
#define HV_ENABLE 8
#define TRIGGER 7
#define PRESSURE_SENSOR A3
#define RELAY_PIN 8
// Constantes Physiques
const float MAX_TEMP = 85.0; // °C
const int COIL_SEQ_DELAY = 250; // μs
const int PRESSURE_MIN = 250; // 0.1 mBar (ADC)
PID tempPID(&tempInput, &tempOutput, &tempSetpoint, 2.5, 0.1, 0.05, DIRECT);
Adafruit_SSD1306 oled(128, 64, &Wire, -1);
Watchdog wdt;
void setup() {
  // Initialisation Matérielle
  pinMode(HV_ENABLE, OUTPUT);
  pinMode(RELAY_PIN, OUTPUT);
  for(int pin : COIL_PINS) pinMode(pin, OUTPUT);
  // Configuration PID
  tempPID.SetOutputLimits(0, 255);
  tempPID.SetSampleTime(100);
  // Interface Utilisateur
  oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  wdt.enable(Watchdog::TIMEOUT_2S);
}
void loop() {
  wdt.reset();
  // Lecture Capteurs
  float temp = readTemperature();
  int pressure = analogRead(PRESSURE_SENSOR);
  // Vérifications Sécurité
  if(temp > MAX_TEMP || pressure < PRESSURE_MIN) {
    emergencyShutdown();
    return;
  }
  // Gestion Déclenchement
  if(digitalRead(TRIGGER) == LOW) {
    executeFireSequence();
  }
  updateDisplay();
}
void executeFireSequence() {
  // Phase 1 : Génération Plasma
  digitalWrite(HV_ENABLE, HIGH);
  delayMicroseconds(100);
  // Phase 2 : Confinement Magnétique
  for(int i=0; i<10; i++) {
    digitalWrite(COIL_PINS[i], HIGH);
    delayMicroseconds(COIL_SEQ_DELAY);
    digitalWrite(COIL_PINS[i], LOW);
  }
  // Phase 3 : Propulsion
  triggerCapacitorBank();
  digitalWrite(HV_ENABLE, LOW);
}
void triggerCapacitorBank() {
  digitalWrite(RELAY_PIN, HIGH);
  delay(50);
  digitalWrite(RELAY_PIN, LOW);
}
float readTemperature() {
  // Conversion ADC → Température (LM35)
  int raw = analogRead(TEMP_SENSOR);
  return raw * (5.0/1024.0) * 100.0;
}
void emergencyShutdown() {
  digitalWrite(HV_ENABLE, LOW);
  for(int pin : COIL_PINS) digitalWrite(pin, LOW);
  oled.clearDisplay();
  oled.println("ARRET D'URGENCE!");
  oled.display();
  while(1) wdt.reset();
}
void updateDisplay() {
  oled.clearDisplay();
  oled.setCursor(0,0);
  oled.print("Temp: "); oled.print(temp); oled.println("C");
  oled.print("Pression: "); oled.print(map(pressure,0,1023,0,1000)); oled.println(" mBar");
  oled.display();
}
            

1️⃣4️⃣ Procédures d'Étalonnage

Feuille d'Étalonnage Type

Date: ___________  Technicien: ___________
Instrument: Capteur de Hall #12
--------------------------------------------------
| Point | Référence | Mesuré | Erreur | Action  |
--------------------------------------------------
| 0.0T  | 0.000     | 0.002  | +0.002 | Ajusté  |
| 1.0T  | 1.000     | 0.997  | -0.003 | Ajusté  |
| 2.0T  | 2.000     | 2.010  | +0.010 | Toléré  |
--------------------------------------------------
Commentaires: Ajustement du trimmer R34
            

1️⃣5️⃣ Résultats Attendus

• Tir Plasma : Arc lumineux guidé.
• Portée : 1-3 mètres.
• Effets : Impact thermique visible, son et lumière impressionnants.
• Durabilité : Environ 10 tirs par charge de batterie.

1️⃣6️⃣ FAQ

Comment éviter une surchauffe ?

Ajoutez des dissipateurs thermiques aux MOSFET.

Comment garantir la sécurité ?

Travaillez avec des gants isolants et gardez une distance de sécurité.

1️⃣7️⃣ Recommandations

Utilisez ce projet uniquement pour des expériences éducatives ou des démonstrations scientifiques. Ne l’utilisez jamais à des fins nuisibles.

1️⃣8️⃣ Crédits et Licence

Créateur : Platon-y pour "PCTamalou" – Passionné de science et d’innovation, dédié à partager des projets éducatifs accessibles à tous.

Contributeurs : Merci à la communauté DIY et aux makers qui inspirent ces projets.

Licence : Ce contenu est sous licence Creative Commons CC BY-NC-SA 4.0 – Attribution, usage non commercial, partage dans les mêmes conditions. Vous pouvez partager et adapter ce guide à condition de créditer "PCTamalou", de ne pas en faire un usage commercial, et de redistribuer sous la même licence. Plus d’infos : CC BY-NC-SA 4.0.

Contact : Pour questions ou collaborations, envoyez un e-mail.